/*
SINACOR - BMF&Bovespa
Arquivo: AlocacaoProprietaria.cs
Criado em: 01-jun-2010 09:19:04
Arquiteto Responsavel: p-Ksantos
*/
using System;
using System.Collections.Generic;
using System.Text;
using Sinacor.Infra.Service.Common;
using Sinacor.Infra.Common.Exceptions;
using Sinacor.Infra.Common.Serialization;
using Sinacor.Infra.Service.ExceptionHandling;
using Sinacor.Infra.Service.Validation;
using Sinacor.Servico.Bovespa.Movimento;
using System.Linq;


namespace Sinacor.Servico.Bovespa.Alocacao.BusinessLogic
{
    /// <summary>
    /// Logica de negcios de Alocacao Proprietaria
    /// </summary>
    public class AlocacaoProprietaria : BaseBusinessLogic
    {
        #region Atributos
        
        private int _erroCancelamentoNegocio = 109707;
        private int _erroExclusaoNegocio = 109728;
        private int _erroGravarSolucao = 109708;
        private int _erroInclusaoNegocio = 109729;
        private int _erroMovimentoOrdens = 109706;
        private int _erroQuantidadeDiferente = 109705;
        private int _erroSolucaoNaoInformada = 109723;

        private Decimal _quantidadeTotalSolucao;
        private Decimal _saldoOcorrenciaZeComZe;
        private Decimal _saldoSolucao;

        private List<Ordens.BusinessEntity.Parameter.CancelarOrdemDistribuida> _listaCancelarOrdemDistribuida;
        ResourceAccess.AlocacaoProprietaria _raAlocacaoProprietaria;

        #endregion

        #region Construtor

        /// <summary>
        /// Construtor AlocacaoProprietaria
        /// </summary>
        public AlocacaoProprietaria()
            : base()
        {
            _raAlocacaoProprietaria = new ResourceAccess.AlocacaoProprietaria();
        }

        #endregion

        #region Propriedades

        /// <summary>
        /// Processo de cancelamento de Negocios com falha.
        /// </summary>
        public int ErroCancelamentoNegocio
        {
            get { return _erroCancelamentoNegocio; }
            set { _erroCancelamentoNegocio = value; }
        }

        /// <summary>
        /// Erro na exclusao da ocorrencia Ze com Ze ou possiveis solucoes
        /// </summary>
        public int ErroExclusaoNegocio
        {
            get { return _erroExclusaoNegocio; }
            set { _erroExclusaoNegocio = value; }
        }

        /// <summary>
        /// Erro na gravacao da solucao.
        /// </summary>
        public int ErroGravarSolucao
        {
            get { return _erroGravarSolucao; }
            set { _erroGravarSolucao = value; }
        }

        /// <summary>
        /// Erro na inclusao da ocorrencia Ze com Ze ou possiveis solucoes
        /// </summary>
        public int ErroInclusaoNegocio
        {
            get { return _erroInclusaoNegocio; }
            set { _erroInclusaoNegocio = value; }
        }

        /// <summary>
        /// Movimento de Ordens nao esta aberto.
        /// </summary>
        public int ErroMovimentoOrdens
        {
            get { return _erroMovimentoOrdens; }
            set { _erroMovimentoOrdens = value; }
        }

        /// <summary>
        /// Cancelamento do Negocio informado nao pode ser efetuado por apresentar diferenca na quantidade.
        /// </summary>
        public int ErroQuantidadeDiferente
        {
            get { return _erroQuantidadeDiferente; }
            set { _erroQuantidadeDiferente = value; }
        }

        /// <summary>
        /// Solucao para o negocio deve ser informada
        /// </summary>
        public int ErroSolucaoNaoInformada
        {
            get { return _erroSolucaoNaoInformada; }
            set { _erroSolucaoNaoInformada = value; }
        }

        public List<Ordens.BusinessEntity.Parameter.CancelarOrdemDistribuida> ListaCancelarOrdemDistribuida
        {
            get { return _listaCancelarOrdemDistribuida; }
            set { _listaCancelarOrdemDistribuida = value; }
        }

        /// <summary>
        /// Quantidade total dos negocios selecionados para solucao da ocorrencia Ze com Ze.
        /// </summary>
        public Decimal QuantidadeTotalSolucao
        {
            get { return _quantidadeTotalSolucao; }
            set { _quantidadeTotalSolucao = value; }
        }

        /// <summary>
        /// Saldo restante da ocorrencia Ze com Ze (Quantidade da ocorrencia Ze com Ze > Quantidade da solucao).
        /// </summary>
        public Decimal SaldoOcorrenciaZeComZe
        {
            get { return _saldoOcorrenciaZeComZe; }
            set { _saldoOcorrenciaZeComZe = value; }
        }

        /// <summary>
        /// Saldo restante da solucao (Quantidade da solucao > Quantidade da ocorrencia Ze com Ze).
        /// </summary>
        public Decimal SaldoSolucao
        {
            get { return _saldoSolucao; }
            set { _saldoSolucao = value; }
        }

        #endregion

        #region Metodos

        #region AtualizarOcorrenciaNegocioDistribuido
        /// <summary>
        /// Atualiza quantidade na tabela TORNEGD.
        /// </summary>
        /// <param name="entity"></param>
        public void AtualizarOcorrenciaNegocioDistribuido(BusinessEntity.Ocorrencia entity)
        {
            _raAlocacaoProprietaria.AtualizarOcorrenciaNegocioDistribuido(entity);
        }
        #endregion

        #region CancelarOcorrenciaCentralDepositaria
        /// <summary>
        /// Cancelamento de ocorrencia/negocio Ze com Ze Central Depositaria.
        /// </summary>
        /// <param name="entity"></param>
        public void CancelarOcorrenciaCentralDepositaria(BusinessEntity.Ocorrencia entity)
        {
            if (entity.Quantidade != entity.QuantidadeNegocio)
            {
                throw new BusinessException(ErroQuantidadeDiferente);
            }
            else
            {
                this.CancelarOcorrenciaSinacor(entity);
            }
        }
        #endregion

        #region CancelarOcorrenciaSinacor
        /// <summary>
        /// Cancelamento de ocorrencia/negocio Ze com Ze.
        /// </summary>
        /// <param name="entity"></param>
        public void CancelarOcorrenciaSinacor(BusinessEntity.Ocorrencia entity)
        {
            try
            {
                //Verificar Movimento de Ordens
                Movimento.BusinessEntity.DataMovimento beDataMovimento = new Movimento.BusinessEntity.DataMovimento();
                beDataMovimento.Valor = entity.DataMovimento;

                Movimento.BusinessLogic.ControleMovimentoOrdens blControleMovimentoOrdens = new Movimento.BusinessLogic.ControleMovimentoOrdens();
                Movimento.BusinessEntity.InformacoesMovimento beInformacoesMovimento = new Movimento.BusinessEntity.InformacoesMovimento();
                beInformacoesMovimento = blControleMovimentoOrdens.ObterInformacoesMovimento(beDataMovimento);

                if (beDataMovimento != null || beInformacoesMovimento.EstadoMovimento == Movimento.BusinessEntity.Enum.TipoMovimento.Aberto)
                {
                    //Insere Log de Negocio Cancelado
                    this.IncluirLogNegocioCancelado(entity);

                    //Identifica ordens casadas com o negocio
                    ListaCancelarOrdemDistribuida = this.ConsultarOrdensCasadasNegocio(entity);

                    //Existem Ordens distribuidas Canceladas?
                    if (ListaCancelarOrdemDistribuida.Count > 0)
                    {
                        Ordens.BusinessLogic.Ordem blOrdem = new Ordens.BusinessLogic.Ordem();
                        blOrdem.CancelarOrdemDistribuida(ListaCancelarOrdemDistribuida);
                    }

                    //Negocio esta casado?
                    if (entity.Ordem > 0)
                    {
                        try
                        {
                            //Executa descasamento da Ordem
                            List<ManutencaoOrdens.BusinessEntity.Negocio> listaNegocio = new List<ManutencaoOrdens.BusinessEntity.Negocio>();
                            ManutencaoOrdens.BusinessEntity.Negocio beNegocio = new ManutencaoOrdens.BusinessEntity.Negocio();
                            beNegocio.Ordem = new ManutencaoOrdens.BusinessEntity.ChaveOrdem();
                            beNegocio.Ordem.DataOrdem = entity.DataOrdem.Value;
                            beNegocio.DataPregao = entity.DataMovimento;
                            beNegocio.Ordem.NumeroOrdem = entity.Ordem.Value;
                            beNegocio.Ordem.NumeroOrdemSubSequencia = entity.SequenciaOrdem.Value;
                            beNegocio.Codigo = entity.Ativo;
                            beNegocio.Numero = entity.Negocio;
                            beNegocio.NaturezaOperacao = ToNaturezaOperacao(entity.NaturezaOperacao);
                            beNegocio.Bolsa = entity.Bolsa;

                            listaNegocio.Insert(0, beNegocio);

                            ManutencaoOrdens.BusinessLogic.Casamento blCasamento = new ManutencaoOrdens.BusinessLogic.Casamento();
                            blCasamento.DescasarNegocios(listaNegocio);
                        }
                        catch (Exception)
                        {
                            throw;
                        }
                    }
                    else
                    {
                        //Cancela Alocacao
                        BusinessEntity.Parameter.FiltroNegocio beFiltroNegocio = new BusinessEntity.Parameter.FiltroNegocio();
                        beFiltroNegocio.Bolsa = entity.Bolsa;
                        beFiltroNegocio.Cliente = entity.CodigoCliente;
                        beFiltroNegocio.CodigoNegocio = entity.Ativo;
                        beFiltroNegocio.DataPregao = entity.DataMovimento;
                        beFiltroNegocio.Mercado = entity.Mercado;
                        beFiltroNegocio.NaturezaOperacao = entity.NaturezaOperacao;
                        beFiltroNegocio.NumeroNegocio = entity.Negocio;

                        List<BusinessEntity.NegocioAlocadoDireto> listaNegocioAlocadoDireto = new List<BusinessEntity.NegocioAlocadoDireto>();
                        BusinessLogic.AlocacaoDireta blAlocacaoDireta = new BusinessLogic.AlocacaoDireta();
                        listaNegocioAlocadoDireto = blAlocacaoDireta.ConsultarNegociosAlocados(beFiltroNegocio);
                        blAlocacaoDireta.ExcluirNegocioAlocado(listaNegocioAlocadoDireto);
                    }

                    // Exclui negocios correspondentes
                    ExcluirCorrespondenteNegocio(entity);
                    ExcluirNegocio(entity);

                    // Quantidade real do negocio - Quantidade do negocio a cancelar > 0 ?
                    if (entity.QuantidadeNegocio - entity.Quantidade > 0)
                    {
                        // Inclui ocorrencia com a quantidade atualizada
                        entity.Quantidade = entity.QuantidadeNegocio.Value - entity.Quantidade;
                        this.IncluirNegocio(entity);

                        // Atualiza quantidade na tabela TORNEGD
                        this.AtualizarOcorrenciaNegocioDistribuido(entity);
                    }
                    else
                    {
                        // Exclui negocios Movimento                        
                        ExcluirMovimentoNegocio(entity);
                    }
                }
                else
                {
                    throw new BusinessException(ErroMovimentoOrdens);
                }
            }
            catch (Exception)
            {
                throw new BusinessException(ErroCancelamentoNegocio);
            }
        }
        #endregion
        
        #region ConsultarOcorrenciasCentralDepositaria
        /// <summary>
        /// Disponibiliza uma lista de ocorrencias que caracterizem Ze com Ze de arquivos
        /// importados da Central Depositaria.
        /// </summary>
        /// <param name="entity"></param>
        public List<BusinessEntity.Ocorrencia> ConsultarOcorrenciasCentralDepositaria(BusinessEntity.Parameter.FiltroOcorrenciaCentralDepositaria entity)
        {
            return _raAlocacaoProprietaria.ConsultarOcorrenciasCentralDepositaria(entity);
        }
        #endregion

        #region ConsultarSolucaoNegocio
        /// <summary>
        /// Disponibiliza uma lista de Ordens de Negocios para solucao.
        /// </summary>
        /// <param name="entity"></param>
        public List<BusinessEntity.NegocioAlocacaoProprietaria> ConsultarSolucaoNegocio(BusinessEntity.Parameter.FiltroSolucaoNegocio entity)
        {
            return _raAlocacaoProprietaria.ConsultarSolucaoNegocio(entity);
        }
        #endregion

        #region ConsultarOcorrenciasSinacor
        /// <summary>
        /// Disponibiliza uma lista de ocorrencias que caracterizem Ze com Ze.
        /// </summary>
        /// <param name="entity"></param>
        public List<BusinessEntity.Ocorrencia> ConsultarOcorrenciasSinacor(BusinessEntity.Parameter.FiltroOcorrenciaSinacor entity)
        {
            return _raAlocacaoProprietaria.ConsultarOcorrenciasSinacor(entity);
        }
        #endregion

        #region ConsultarOrdensCasadasNegocio
        /// <summary>
        /// Identifica Ordens casadas com o Negocio.
        /// </summary>
        /// <param name="entity"></param>
        public List<Ordens.BusinessEntity.Parameter.CancelarOrdemDistribuida> ConsultarOrdensCasadasNegocio(BusinessEntity.Ocorrencia entity)
        {
            return _raAlocacaoProprietaria.ConsultarOrdensCasadasNegocio(entity);
        }
        #endregion

        #region ExcluirExecucao
        /// <summary>
        /// Exclui Negocio informado da tabela TOREXEC.
        /// </summary>
        /// <param name="entity"></param>
        public void ExcluirExecucao(BusinessEntity.NegocioAlocacaoProprietaria entity)
        {
            try
            {
                _raAlocacaoProprietaria.ExcluirExecucao(entity);
            }
            catch (Exception)
            {
                throw new BusinessException(ErroExclusaoNegocio);
            }
        }

        /// <summary>
        /// Exclui uma lista de Negocios informados da tabela TOREXEC.
        /// </summary>
        /// <param name="entity"></param>
        public void ExcluirExecucao(List<BusinessEntity.NegocioAlocacaoProprietaria> entity)
        {
            foreach (BusinessEntity.NegocioAlocacaoProprietaria negocio in entity)
            {
                this.ExcluirExecucao(negocio);
            }
        }
        #endregion

        #region ExcluirNegocio
        /// <summary>
        /// Exclui Negocio informado da tabela TORCOMI.
        /// </summary>
        /// <param name="entity"></param>
        public void ExcluirNegocio(BusinessEntity.NegocioAlocacaoProprietaria entity)
        {
            try
            {
                _raAlocacaoProprietaria.ExcluirNegocio(entity);
            }
            catch (Exception)
            {
                throw new BusinessException(ErroExclusaoNegocio);
            }
        }
        
        /// <summary>
        /// Exclui uma lista de Negocios informados da tabela TORCOMI.
        /// </summary>
        /// <param name="entity"></param>
        public void ExcluirNegocio(List<BusinessEntity.NegocioAlocacaoProprietaria> entity)
        {
            foreach (BusinessEntity.NegocioAlocacaoProprietaria negocio in entity)
            {
                this.ExcluirNegocio(negocio);
            }
        }
        #endregion

        #region ExcluirCorrespondenteNegocio
        /// <summary>
        /// Excluir registros correspondentes do Negocio informado da tabela TORCOMI.
        /// </summary>
        /// <param name="entity"></param>
        public void ExcluirCorrespondenteNegocio(BusinessEntity.Ocorrencia entity)
        {
            _raAlocacaoProprietaria.ExcluirCorrespondenteNegocio(entity);
        }
        #endregion

        #region ExcluirMovimentoNegocio
        /// <summary>
        /// Excluir Negocios do Movimento da tabela TORNEGD.
        /// </summary>
        /// <param name="entity"></param>
        public void ExcluirMovimentoNegocio(BusinessEntity.Ocorrencia entity)
        {
            _raAlocacaoProprietaria.ExcluirMovimentoNegocio(entity);
        }
        #endregion

        #region IncluirExecucao
        /// <summary>
        /// Inclui Negocio informado na tabela TOREXEC.
        /// </summary>
        /// <param name="entity"></param>
        public void IncluirExecucao(BusinessEntity.NegocioAlocacaoProprietaria entity)
        {
            try
            {
                _raAlocacaoProprietaria.IncluirExecucao(entity);
            }
            catch (Exception)
            {
                throw new BusinessException(ErroInclusaoNegocio);
            }
        }
        #endregion

        #region IncluirLogNegocioCancelado
        /// <summary>
        /// Inclui Log do nogocio cancelado.
        /// </summary>
        /// <param name="entity"></param>
        public void IncluirLogNegocioCancelado(BusinessEntity.Ocorrencia entity)
        {
            _raAlocacaoProprietaria.IncluirLogNegocioCancelado(entity);
        }
        #endregion

        #region IncluirNegocio
        /// <summary>
        /// Inclui negocio na tabela TORCOMI.
        /// </summary>
        /// <param name="entity"></param>
        public void IncluirNegocio(BusinessEntity.NegocioAlocacaoProprietaria entity)
        {
            try
            {
                _raAlocacaoProprietaria.IncluirNegocio(entity);
            }
            catch (Exception)
            {
                throw new BusinessException(ErroInclusaoNegocio);
            }
        }
        #endregion

        #region SolucionarOcorrencia
        /// <summary>
        /// Soluciona ocorrencia Ze com Ze.
        /// </summary>
        /// <param name="entity"></param>
        public void SolucionarOcorrencia(BusinessEntity.Ocorrencia entity)
        {
            if (entity.SolucaoNegocio != null)
            {
                // Calcula quantidade total da solucao Ze com Ze
                foreach (BusinessEntity.NegocioAlocacaoProprietaria itemSolucao in entity.SolucaoNegocio)
                {
                    QuantidadeTotalSolucao += itemSolucao.Quantidade;
                }

                // Quantidade negocio a ser acertado = Quantidade Total Solucao
                if (entity.Quantidade == QuantidadeTotalSolucao)
                {
                    // Exclui e inclui ocorrencia e solucao
                    ExclusoesOcorrenciaZecomZe(entity);
                    InclusoesOcorrenciaZecomZe(entity);
                }
                // Quantidade Negocio a ser acertado > Quantidade Total Solucao
                else
                {                    
                    if (entity.Quantidade > QuantidadeTotalSolucao)
                    {                      
                        // Exclui ocorrencia e solucao
                        ExclusoesOcorrenciaZecomZe(entity);

                        // Inclui negocio a ser acertado com restante da quantidade
                        entity.Quantidade -= QuantidadeTotalSolucao;
                        IncluirNegocio(entity);
                        IncluirExecucao(entity);

                        // Inclui ocorrencia e solucao
                        entity.Quantidade = QuantidadeTotalSolucao;
                        InclusoesOcorrenciaZecomZe(entity);
                    }
                    // Quantidade Negocio a ser acertado < Quantidade Total Solucao
                    else
                    {
                        // Copia ocorrencia a ser acertada
                        BusinessEntity.Ocorrencia ocorrencia = (BusinessEntity.Ocorrencia)entity.Clone();

                        // Ordena lista de solucoes por quantidade
                        List<BusinessEntity.NegocioAlocacaoProprietaria> listaSolucoes = entity.SolucaoNegocio.OrderByDescending(order => order.Quantidade).ToList<BusinessEntity.NegocioAlocacaoProprietaria>();

                        // Exclui ocorrencia e solucao
                        ExclusoesOcorrenciaZecomZe(entity);

                        decimal qtdeAcertada;
                        decimal qtdeRestante;

                        for (int i = 0; i < listaSolucoes.Count; i++)
                        {
                            qtdeAcertada = 0;
                            qtdeRestante = 0;                            

                            if (listaSolucoes[i].Quantidade > entity.Quantidade)
                            {
                                qtdeAcertada = entity.Quantidade;
                                qtdeRestante = listaSolucoes[i].Quantidade - entity.Quantidade;

                                // Incluir nova solucao com quantidade atualizada
                                listaSolucoes[i].Quantidade = qtdeRestante;
                                IncluirNegocio(listaSolucoes[i]);
                                IncluirExecucao(listaSolucoes[i]);

                                // Inclui negocio a ser acertado
                                entity.Negocio = listaSolucoes[i].Negocio;
                                entity.DigitoNegocio = listaSolucoes[i].DigitoNegocio;
                                entity.Ativo = listaSolucoes[i].Ativo;

                                IncluirNegocio(entity);
                                IncluirExecucao(entity);

                                // Inclui solucao
                                listaSolucoes[i].Quantidade = qtdeAcertada;
                                listaSolucoes[i].Negocio = ocorrencia.Negocio;
                                listaSolucoes[i].DigitoNegocio = ocorrencia.DigitoNegocio;
                                listaSolucoes[i].Ativo = ocorrencia.Ativo;

                                IncluirNegocio(listaSolucoes[i]);
                                IncluirExecucao(listaSolucoes[i]);                                                                                               

                                entity.Quantidade = 0;
                            }
                            else
                            {
                                qtdeAcertada = listaSolucoes[i].Quantidade;
                                qtdeRestante = entity.Quantidade - listaSolucoes[i].Quantidade;
                                
                                // Inclui negocio a ser acertado
                                entity.Quantidade = qtdeAcertada;
                                entity.Negocio = listaSolucoes[i].Negocio;
                                entity.DigitoNegocio = listaSolucoes[i].DigitoNegocio;
                                entity.Ativo = listaSolucoes[i].Ativo;

                                IncluirNegocio(entity);
                                IncluirExecucao(entity);

                                entity.Quantidade = qtdeRestante;

                                // Inclui solucao
                                listaSolucoes[i].Negocio = ocorrencia.Negocio;
                                listaSolucoes[i].DigitoNegocio = ocorrencia.DigitoNegocio;
                                listaSolucoes[i].Ativo = ocorrencia.Ativo;

                                IncluirNegocio(listaSolucoes[i]);
                                IncluirExecucao(listaSolucoes[i]);
                            }
                            
                            // Quantidade da ocorrencia a ser acertada = 0
                            if (entity.Quantidade == 0)
                            {
                                break;
                            }
                        }
                    }
                }
            }
            else
            {
                throw new BusinessException(ErroMovimentoOrdens);
            }
        }

        #endregion

        #endregion

        #region Metodos Privados              

        #region InclusoesOcorrenciaZecomZe
        private void InclusoesOcorrenciaZecomZe(BusinessEntity.Ocorrencia entity)
        {          
            BusinessEntity.Ocorrencia ocorrencia = (BusinessEntity.Ocorrencia)entity.Clone();
                        
            for (int i = 0; i < entity.SolucaoNegocio.Count; i++)
            {
                // Inclui ocorrencia a ser acertada
                entity.Quantidade = entity.SolucaoNegocio[i].Quantidade;
                entity.Negocio = entity.SolucaoNegocio[i].Negocio;
                entity.DigitoNegocio = entity.SolucaoNegocio[i].DigitoNegocio;
                entity.Ativo = entity.SolucaoNegocio[i].Ativo;

                IncluirNegocio(entity);
                IncluirExecucao(entity);
                
                // Inclui solucao da ocorrencia
                entity.SolucaoNegocio[i].Negocio = ocorrencia.Negocio;
                entity.SolucaoNegocio[i].DigitoNegocio = ocorrencia.DigitoNegocio;
                entity.SolucaoNegocio[i].Ativo = ocorrencia.Ativo;

                IncluirNegocio(entity.SolucaoNegocio[i]);
                IncluirExecucao(entity.SolucaoNegocio[i]);
            }
        }
        #endregion

        #region ExclusoesOcorrenciaZecomZe
        private void ExclusoesOcorrenciaZecomZe(BusinessEntity.Ocorrencia entity)
        {
            // Excluir negocios TORCOMI
            ExcluirNegocio(entity);
            ExcluirNegocio(entity.SolucaoNegocio);

            // Excluir negocios TOREXEC
            ExcluirExecucao(entity);
            ExcluirExecucao(entity.SolucaoNegocio);
        }
        #endregion

        #region ToNaturezaOperacao
        private ManutencaoOrdens.BusinessEntity.Enum.NaturezaOperacao ToNaturezaOperacao(BusinessEntity.Enum.NaturezaOperacao naturezaOperacao)
        {
            ManutencaoOrdens.BusinessEntity.Enum.NaturezaOperacao to = new ManutencaoOrdens.BusinessEntity.Enum.NaturezaOperacao();

            switch (naturezaOperacao)
            {
                case BusinessEntity.Enum.NaturezaOperacao.Compra:
                    to = ManutencaoOrdens.BusinessEntity.Enum.NaturezaOperacao.Compra;
                    break;
                case BusinessEntity.Enum.NaturezaOperacao.CompraVenda:
                    to = ManutencaoOrdens.BusinessEntity.Enum.NaturezaOperacao.CompraVenda;
                    break;
                case BusinessEntity.Enum.NaturezaOperacao.Venda:
                    to = ManutencaoOrdens.BusinessEntity.Enum.NaturezaOperacao.Venda;
                    break;
                default:
                    break;
            }

            return to;
        }
        #endregion

        #endregion
    }
}